/**
 * 用户状态管理Context
 * 提供全局用户状态管理，包括登录、退出、用户信息更新等功能
 */
import React, { createContext, useState, useContext, useEffect } from 'react';
import AsyncStorage from '@react-native-async-storage/async-storage';
import { userAPI } from '../api';

// 创建用户Context
const UserContext = createContext(null);

// 本地存储的键名
const STORAGE_KEYS = {
  TOKEN: 'user_token', // 用户Token
  USER_INFO: 'user_info', // 用户信息
};

/**
 * 用户状态Provider组件
 * 包裹在App根组件外层，为所有子组件提供用户状态
 */
export const UserProvider = ({ children }) => {
  // 用户信息状态
  const [user, setUser] = useState(null);
  // 登录Token状态
  const [token, setToken] = useState(null);
  // 加载状态（用于App启动时恢复用户状态）
  const [isLoading, setIsLoading] = useState(true);

  // 组件挂载时，从本地存储加载用户信息
  useEffect(() => {
    loadUserFromStorage();
  }, []);

  /**
   * 从本地存储加载用户信息
   * App启动时自动调用，实现自动登录
   * 如果有token，会自动请求服务器获取最新用户信息
   */
  const loadUserFromStorage = async () => {
    try {
      const [savedToken, savedUserInfo] = await Promise.all([
        AsyncStorage.getItem(STORAGE_KEYS.TOKEN),
        AsyncStorage.getItem(STORAGE_KEYS.USER_INFO),
      ]);

      if (savedToken && savedUserInfo) {
        // 先设置本地缓存的数据，让用户立即看到界面
        const cachedUser = JSON.parse(savedUserInfo);
        setToken(savedToken);
        setUser(cachedUser);

        // 然后请求服务器获取最新用户信息
        try {
          const response = await userAPI.getProfile();

          // 处理返回数据
          let userData = null;
          if (response?.data?.data) {
            // 格式1: { data: { code: 200, data: {...} } }
            userData = response.data.data;
          } else if (response?.data) {
            // 格式2: { data: {...} }
            userData = response.data;
          }

          if (userData) {
            setUser(userData);
            await saveUserToStorage(savedToken, userData);
          }
        } catch (error) {
          // 如果是401未授权错误，说明token过期，清除本地缓存
          if (
            error.message?.includes('401') ||
            error.message?.includes('未授权') ||
            error.message?.includes('token')
          ) {
            setToken(null);
            setUser(null);
            await clearUserFromStorage();
          }
        }
      }
    } catch {
      // 加载用户信息异常
    } finally {
      setIsLoading(false);
    }
  };

  /**
   * 保存用户信息到本地存储
   * @param {string} userToken - 用户Token
   * @param {Object} userInfo - 用户信息对象
   */
  const saveUserToStorage = async (userToken, userInfo) => {
    try {
      await Promise.all([
        AsyncStorage.setItem(STORAGE_KEYS.TOKEN, userToken),
        AsyncStorage.setItem(STORAGE_KEYS.USER_INFO, JSON.stringify(userInfo)),
      ]);
    } catch {
      // 保存失败，忽略错误
    }
  };

  /**
   * 清除本地存储的用户信息
   */
  const clearUserFromStorage = async () => {
    try {
      await Promise.all([
        AsyncStorage.removeItem(STORAGE_KEYS.TOKEN),
        AsyncStorage.removeItem(STORAGE_KEYS.USER_INFO),
      ]);
    } catch {
      // 清除失败，忽略错误
    }
  };

  /**
   * 登录
   * 验证码登录成功后调用此方法保存用户状态
   * @param {string} userToken - 登录Token
   * @param {Object} userInfo - 用户信息对象
   */
  const login = async (userToken, userInfo) => {
    setToken(userToken);
    setUser(userInfo);
    await saveUserToStorage(userToken, userInfo);
  };

  /**
   * 退出登录
   * 清除本地和服务器的登录状态
   */
  const logout = async () => {
    try {
      // 调用退出登录API
      await userAPI.logout();
    } catch {
      // API调用失败，继续清除本地状态
    } finally {
      // 无论API是否成功，都清除本地状态
      setToken(null);
      setUser(null);
      await clearUserFromStorage();
    }
  };

  /**
   * 更新用户信息
   * 本地更新用户信息（如修改昵称、头像等）
   * @param {Object} newUserInfo - 新的用户信息（会与现有信息合并）
   */
  const updateUser = async newUserInfo => {
    const updatedUser = { ...user, ...newUserInfo };
    setUser(updatedUser);
    await saveUserToStorage(token, updatedUser);
  };

  /**
   * 刷新用户信息
   * 从服务器获取最新的用户信息
   */
  const refreshUserInfo = async () => {
    try {
      const response = await userAPI.getProfile();

      // 处理返回数据结构
      if (response?.data?.data) {
        // 如果返回格式是 { data: { code: 200, data: {...} } }
        const userData = response.data.data;
        await updateUser(userData);
        return userData;
      } else if (response?.data) {
        // 如果返回格式是 { data: {...} }
        await updateUser(response.data);
        return response.data;
      }
    } catch (error) {
      // 刷新失败，抛出错误给调用方处理
      throw error;
    }
  };

  // 提供给子组件的值
  const value = {
    user,
    token,
    isLoading,
    isLoggedIn: !!token && !!user, // 直接计算布尔值，确保状态变化时自动更新
    login,
    logout,
    updateUser,
    refreshUserInfo,
  };

  return <UserContext.Provider value={value}>{children}</UserContext.Provider>;
};

/**
 * 使用用户状态的自定义Hook
 * 在任何组件中使用此Hook获取用户状态和操作方法
 *
 * @example
 * const { user, isLoggedIn, login, logout } = useUser();
 *
 * @returns {Object} 用户状态和操作方法
 */
export const useUser = () => {
  const context = useContext(UserContext);
  if (!context) {
    throw new Error('useUser必须在UserProvider内使用');
  }
  return context;
};

export default UserContext;
